/*
 * Copyright (C) 2021 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import app from '@system.app'
import {describe,beforeAll,beforeEach,afterEach,afterAll,it,expect} from '@ohos/hypium'

export default function webgl1Test_webgl1(){
	describe('webgl1Test_webgl1', function() {
		console.info('webgltest start');
		var gl;
		var gl2;

		var indices = new Uint16Array([0, 1, 2, 1, 3, 4]);
		var vertices = new Uint16Array([
			-0.5, 0.5, 0.0,
			0.0, 0.5, 0.0,
			-0.25, 0.25, 0.0,
			0.5, 0.5, 0.0,
			0.25, 0.25, 0.0,
		])

		//顶点着色器程序
		var VSHADER_SOURCE =
			"attribute vec4 a_Position;" +
			"void main() {" +
			//设置坐标
			"gl_Position = a_Position; " +
			//    "gl_PointSize = 10.0;" +
			"} ";

		//片元着色器
		var FSHADER_SOURCE =
			"void main() {" +
			//设置颜色
			"gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);" +
			"}";

		function globalFunction() {
			const vertexShader = gl.createShader(gl.VERTEX_SHADER);
			gl.shaderSource(vertexShader, VSHADER_SOURCE);
			gl.compileShader(vertexShader);
			const fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
			gl.shaderSource(fragmentShader, FSHADER_SOURCE);
			gl.compileShader(fragmentShader);
			const programObj = gl.createProgram();
			console.info("testUseProgram has failed for " + programObj)
			const useProgramError1 = gl.getError();
			console.info("useProgramError: " + useProgramError1);
			const renderBufferValue1 = gl.getParameter(gl.CURRENT_PROGRAM);
			console.info("testUseProgram has failed for " + renderBufferValue1)
			gl.attachShader(programObj, vertexShader);
			gl.attachShader(programObj, fragmentShader);
			gl.linkProgram(programObj);
			gl.useProgram(programObj);
			return programObj;
		}


		function createProgram(gl) {
			//顶点着色器程序
			var VSHADER_SOURCE =
				'attribute vec4 a_Position;\n' +
				'void main() {\n' +
				'  gl_Position = a_Position;\n' +
				'}\n';

			// 片元着色器程序
			var FSHADER_SOURCE =
				'precision mediump float;\n' +
				'uniform vec4 u_FragColor;\n' +
				'void main() {\n' +
				'  gl_FragColor = u_FragColor;\n' +
				'}\n';
			var vertexShader = gl.createShader(gl.VERTEX_SHADER);
			gl.shaderSource(vertexShader, VSHADER_SOURCE);
			gl.compileShader(vertexShader);
			var fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
			gl.shaderSource(fragmentShader, FSHADER_SOURCE);
			gl.compileShader(fragmentShader);
			const programObj = gl.createProgram();
			console.log("testUseProgram has failed for " + programObj)
			const useProgramError1 = gl.getError();
			console.info("useProgramError: " + useProgramError1);
			const renderBufferValue1 = gl.getParameter(gl.CURRENT_PROGRAM);
			console.log("testUseProgram has failed for " + renderBufferValue1)
			gl.attachShader(programObj, vertexShader);
			gl.attachShader(programObj, fragmentShader);
			gl.linkProgram(programObj);
			gl.useProgram(programObj);
			return programObj;
		}

		function initShaders(gl, vshader, fshader) {
			var program = createProgramExternal(gl, vshader, fshader);
			console.log("======createProgram program: " + JSON.stringify(program));

			if (!program) {
				console.log('Failed to create program');
				return false;
			}

			gl.useProgram(program);
			gl.program = program;

			return true;
		}

		function createProgramExternal(gl, vshader, fshader) {
			// Create shader object
			var vertexShader = loadShader(gl, gl.VERTEX_SHADER, vshader);
			console.log("======vertexShader: " + vertexShader);
			var fragmentShader = loadShader(gl, gl.FRAGMENT_SHADER, fshader);
			if (!vertexShader || !fragmentShader) {
				return null;
			}

			// Create a program object
			var program = gl.createProgram();
			console.log("======createProgram program: " + JSON.stringify(program));

			if (!program) {
				return null;
			}

			// Attach the shader objects
			gl.attachShader(program, vertexShader);
			gl.attachShader(program, fragmentShader);

			// Link the program object
			gl.linkProgram(program);

			// Check the result of linking
			var linked = gl.getProgramParameter(program, 0x8B82);
			console.log("======getProgramParameter linked: " + linked);

			const getUniformLocationValue = gl.getUniformLocation(program, "a_Position");
			console.log("======getUniformLocation: " + JSON.stringify(getUniformLocationValue));


			if (!linked) {
				var error = gl.getProgramInfoLog(program);
				console.log('Failed to link program: ' + error);
				gl.deleteProgram(program);
				gl.deleteShader(fragmentShader);
				gl.deleteShader(vertexShader);
				return null;
			}

			return program;
		}

		function loadShader(gl, type, source) {
			console.log("======into loadShader====");
			// Create shader object
			var shader = gl.createShader(type);
			if (shader == null) {
				console.log('unable to create shader');
				return null;
			}

			const isShaderValue = gl.isShader(shader);
			console.log('isShader: ' + isShaderValue);

			// Set the shader program
			gl.shaderSource(shader, source);

			// Compile the shader
			gl.compileShader(shader);

			// Check the result of compilation
			var compiled = gl.getShaderParameter(shader, gl.COMPILE_STATUS);
			if (!compiled) {
				var error = gl.getShaderInfoLog(shader);
				console.log('Failed to compile shader: ' + error);
				gl.deleteShader(shader);
				return null;
			}

			var vertex = gl.getShaderParameter(shader, gl.VERTEX_SHADER);
			console.log('getShaderParameter VERTEX_SHADER: ' + vertex);


			return shader;
		}

		function initVertexBuffers(gl) {
			var vertices = new Float32Array([
				0.0, -1.0, -0.5, 0, 0.5, 0
			]);

			var n = 3; // 点的个数

			// 创建缓冲区对象
			var vertexBuffer = gl.createBuffer();
			if (!vertexBuffer) {
				console.log('Failed to create the buffer object');
				return -1;
			}

			// 将缓冲区对象绑定到目标
			gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer);
			// 向缓冲区对象写入数据
			gl.bufferData(gl.ARRAY_BUFFER, vertices.buffer, gl.STATIC_DRAW);

			var aPosition = gl.getAttribLocation(gl.program, 'a_Position');
			console.info("webgl# getAttribLocation getAttribLocation success:" + JSON.stringify(gl.program));
			console.info("webgl# getAttribLocation getAttribLocation success:" + aPosition);
			if (aPosition < 0) {
				console.log('Failed to get the storage location of a_Position');
				return -1;
			}
			// 将缓冲区对象分配给a_Position变量
			gl.vertexAttribPointer(aPosition, 2, gl.FLOAT, false, 0, 0);

			// 连接a_Position变量与分配给它的缓冲区对象
			gl.enableVertexAttribArray(aPosition);

			return n;
		}


		var float1 = new Float32Array([1.1, 1.2, 1.3, 1.4]);
		var int1 = new Int8Array([1, 1, 1, 1]);
		var uint1 = new Uint8Array([1, 1, 1, 1]);
		var float2 = [1.1, 1.2, 1.3, 1.4];
		var int2 = [1, 1, 1, 1];
		var uint2 = [1, 1, 1, 1];

		function initContext() {
			console.info('initContext start');
			// 获取canvas元素
			const canvas = global.el;
			const canvas2 = global.el2;
			// 获取webgl上下文
			gl = canvas.getContext('webgl');
			if (!gl) {
				console.log('webgltest Failed to get the rendering context for WebGL');
			}
			gl2 = canvas2.getContext('webgl2');
			if (!gl) {
				console.log('webgltest Failed to get the rendering context for WebGL2');
			}
			console.info('webgltest initContext finish');
		}

		function deleteContext() {
			if (gl != null) {
				gl = null;
				console.info("webgltest gl has null");
			}
			if (gl2 != null) {
				console.info("webgltest gl2 has null");
				gl2 = null;
			}
		}

		/**
		 * run before testClass
		 */
		beforeAll(async function(done) {
			console.info('webgltest beforeAll called');
			initContext();
			done();
		});

		/**
		 * run after testClass
		 */
		afterAll(async function(done) {
			console.info('webgltest afterEach called');
			deleteContext();
			done();
		})

		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_0100
		 * @tc.name webgl_test_getContextAttributes
		 * @tc.desc Test getContextAttributes.
		 */
		it('webgl_test_getContextAttributes', 0, async function(done) {
			console.info("webgltest into getContextAttributes");
			const getContextAttributesValue = gl.getContextAttributes();
			const alphaValue = getContextAttributesValue.alpha;
			console.info("webgltest getContextAttributes: " + getContextAttributesValue);
			expect(typeof(getContextAttributesValue)).assertEqual("object" || null);
			done();
		})

		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_0200
		 * @tc.name webgl_test_isContextLost
		 * @tc.desc Test isContextLost.
		 */
		it('webgl_test_isContextLost', 0, async function(done) {
			console.info("webgltest into isContextLost");
			const isContextLostValue = gl.isContextLost();
			console.info("webgltest isContextLost: " + isContextLostValue);
			expect(isContextLostValue).assertEqual(false);
			done();
		})

		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_0300
		 * @tc.name webgl_test_getSupportedExtensions
		 * @tc.desc Test getSupportedExtensions.
		 */
		it('webgl_test_getSupportedExtensions', 0, async function(done) {
			
			console.info("webgltest into getSupportedExtensions");
			const getSupportedExtensionsValue = gl.getSupportedExtensions();
			console.info("webgltest getSupportedExtensions: " + getSupportedExtensionsValue);
			expect(typeof(getSupportedExtensionsValue)).assertEqual('object');
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_0400
		 * @tc.name webgl_test_getExtension
		 * @tc.desc Test getExtension.
		 */
		it('webgl_test_getExtension', 0, async function(done) {
			
			console.info("webgltest into getExtension");
			const getExtensionValue = gl.getExtension();
			console.info("webgltest getExtension: " + getExtensionValue);
			expect(getExtensionValue).assertEqual(undefined);
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_0500
		 * @tc.name webgl_test_activeTexture
		 * @tc.desc Test activeTexture.
		 */
		it('webgl_test_activeTexture', 0, async function(done) {
			
			console.info("webgltest into activeTexture");
			gl.activeTexture(gl.TEXTURE0);
			const activeTextureParameter = gl.getParameter(gl.ACTIVE_TEXTURE);
			console.info("webgltest activeTexture --> getParameter: " + activeTextureParameter);
			expect(activeTextureParameter).assertEqual(33984);
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_0600
		 * @tc.name webgl_test_activeTexture_1
		 * @tc.desc Test activeTexture.
		 */
		it('webgl_test_activeTexture_1', 0, async function(done) {
			
			console.info("webgltest into activeTexture");
			gl.activeTexture(gl.TEXTURE1);
			const activeTextureParameter = gl.getParameter(gl.ACTIVE_TEXTURE);
			console.info("webgltest activeTexture --> getParameter: " + activeTextureParameter);
			expect(activeTextureParameter).assertEqual(33985);
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_0700
		 * @tc.name webgl_test_attachShader
		 * @tc.desc Test attachShader.
		 */
		it('webgl_test_attachShader', 0, async function(done) {
			
			console.info("webgltest into attachShader");

			//顶点着色器程序
			var VSHADER_SOURCE =
				'attribute vec4 a_Position;\n' +
				'void main() {\n' +
				'  gl_Position = a_Position;\n' +
				'}\n';

			// 片元着色器程序
			var FSHADER_SOURCE =
				'precision mediump float;\n' +
				'uniform vec4 u_FragColor;\n' +
				'void main() {\n' +
				'  gl_FragColor = u_FragColor;\n' +
				'}\n';
			var vertexShader = gl.createShader(gl.VERTEX_SHADER);
			gl.shaderSource(vertexShader, VSHADER_SOURCE);
			gl.compileShader(vertexShader);
			var fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
			gl.shaderSource(fragmentShader, FSHADER_SOURCE);
			gl.compileShader(fragmentShader);
			const programObj = gl.createProgram();
			console.log("testUseProgram has failed for " + programObj)
			const useProgramError1 = gl.getError();
			console.info("useProgramError: " + useProgramError1);
			const renderBufferValue1 = gl.getParameter(gl.CURRENT_PROGRAM);
			console.log("testUseProgram has failed for " + renderBufferValue1)
			gl.attachShader(programObj, vertexShader);
			gl.attachShader(programObj, fragmentShader);
			gl.linkProgram(programObj);
			gl.useProgram(programObj);

			let errorCode = gl.getError();
			console.info("webgltest attachShader getError: " + errorCode);
			expect(errorCode).assertEqual(gl.NO_ERROR);
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_0800
		 * @tc.name webgl_test_bindAttribLocation
		 * @tc.desc Test bindAttribLocation.
		 */
		it('webgl_test_bindAttribLocation', 0, async function(done) {
			
			console.info("webgltest into bindAttribLocation");

			//顶点着色器程序
			var VSHADER_SOURCE =
				'attribute vec4 a_Position;\n' +
				'void main() {\n' +
				'  gl_Position = a_Position;\n' +
				'}\n';

			// 片元着色器程序
			var FSHADER_SOURCE =
				'precision mediump float;\n' +
				'uniform vec4 u_FragColor;\n' +
				'void main() {\n' +
				'  gl_FragColor = u_FragColor;\n' +
				'}\n';
			var vertexShader = gl.createShader(gl.VERTEX_SHADER);
			gl.shaderSource(vertexShader, VSHADER_SOURCE);
			gl.compileShader(vertexShader);
			var fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
			gl.shaderSource(fragmentShader, FSHADER_SOURCE);
			gl.compileShader(fragmentShader);
			const programObj = gl.createProgram();
			console.log("testUseProgram has failed for " + programObj)
			const useProgramError1 = gl.getError();
			console.info("useProgramError: " + useProgramError1);
			const renderBufferValue1 = gl.getParameter(gl.CURRENT_PROGRAM);
			console.log("testUseProgram has failed for " + renderBufferValue1)
			gl.attachShader(programObj, vertexShader);
			gl.attachShader(programObj, fragmentShader);
			gl.linkProgram(programObj);
			gl.useProgram(programObj);

			gl.bindAttribLocation(programObj, 1, 'a_Position');

			let errorCode = gl.getError();
			console.info("webgltest bindAttribLocation getError: " + errorCode);
			expect(errorCode).assertEqual(gl.NO_ERROR);
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_0900
		 * @tc.name webgl_test_bindBuffer
		 * @tc.desc Test bindBuffer.
		 */
		it('webgl_test_bindBuffer', 0, async function(done) {
			
			console.info("webgltest into bindBuffer");

			var buffer = gl.createBuffer();

			gl.bindBuffer(gl.ARRAY_BUFFER, buffer);

			//bind后isBuffer为true
			const isBufferValue = gl.isBuffer(buffer);
			console.info("isBufferValue: " + isBufferValue);
			expect(isBufferValue).assertEqual(true);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_1000
		 * @tc.name webgl_test_bindBuffer_1
		 * @tc.desc Test bindBuffer.
		 */
		it('webgl_test_bindBuffer_1', 0, async function(done) {
			
			console.info("webgltest into bindBuffer");

			var buffer = gl.createBuffer();

			// bind前isBuffer为false
			const isBufferValue0 = gl.isBuffer(buffer);
			console.info("webgltest isBufferValue0: " + isBufferValue0);
			expect(isBufferValue0).assertEqual(false);

			gl.bindBuffer(gl.ARRAY_BUFFER, buffer);

			//bind后isBuffer为true
			const isBufferValue = gl.isBuffer(buffer);
			console.info("isBufferValue: " + isBufferValue);
			expect(isBufferValue).assertEqual(true);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_1100
		 * @tc.name webgl_test_bindFramebuffer
		 * @tc.desc Test bindFramebuffer.
		 */
		it('webgl_test_bindFramebuffer', 0, async function(done) {
			
			console.info("webgltest into bindFramebuffer");

			var framebuffer = gl.createFramebuffer();

			const isFramebuffer1 = gl.isFramebuffer(framebuffer);
			console.info("createFramebuffer --> isFramebuffer1: " + isFramebuffer1);
			expect(isFramebuffer1).assertEqual(false);

			// bind
			gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);

			const isFrameBuffer2 = gl.isFramebuffer(framebuffer);
			console.info("createFramebuffer --> bindFramebuffer --> isFrameBuffer2: " +
				isFrameBuffer2);
			expect(isFrameBuffer2).assertEqual(true);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_1200
		 * @tc.name webgl_test_bindRenderbuffer
		 * @tc.desc Test bindRenderbuffer.
		 */
		it('webgl_test_bindRenderbuffer', 0, async function(done) {
			
			console.info("webgltest into bindRenderbuffer");

			var renderbuffer = gl.createRenderbuffer();

			//不 bindRenderbuffer, 那么下面会返回 false
			const isRenderBuffer0 = gl.isRenderbuffer(renderbuffer);
			console.info("createRenderbuffer --> isRenderbuffer0: " + isRenderBuffer0);
			expect(isRenderBuffer0).assertEqual(false);

			gl.bindRenderbuffer(gl.RENDERBUFFER, renderbuffer);

			// bindRenderbuffer后, isRenderbuffer返回true
			const isRenderBuffer1 = gl.isRenderbuffer(renderbuffer);
			console.info("createRenderbuffer --> bindRenderbuffer --> isRenderbuffer: " +
				isRenderBuffer1);
			expect(isRenderBuffer1).assertEqual(true);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_1300
		 * @tc.name webgl_test_bindTexture
		 * @tc.desc Test bindTexture.
		 */
		it('webgl_test_bindTexture', 0, async function(done) {
			
			console.info("webgltest into bindTexture");

			var texture = gl.createTexture();

			const isTexture0 = gl.isTexture(texture);
			console.info("createTexture --> isTexture: " + isTexture0);
			expect(isTexture0).assertEqual(false);

			gl.bindTexture(gl.TEXTURE_2D, texture);

			const isTexture1 = gl.isTexture(texture);
			console.info("createTexture --> bindTexture --> isTexture: " + isTexture1);
			expect(isTexture1).assertEqual(true);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_1400
		 * @tc.name webgl_test_blendColor
		 * @tc.desc Test blendColor.
		 */
		it('webgl_test_blendColor', 0, async function(done) {
			
			console.info("webgltest into blendColor");

			gl.blendColor(0, 0.5, 1, 1);
			const blendColorValue = gl.getParameter(gl.BLEND_COLOR);
			console.info("blendColor --> getParameter: " + blendColorValue);

			var blendColorArr = new Float32Array([0, 0.5, 1, 1]);

			// 判断数据类型是否正确
			expect(blendColorValue.constructor).assertEqual(blendColorArr.constructor);
			// 判断数据值是否正确
			expect(blendColorValue.toString()).assertEqual(blendColorArr.toString());

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_1500
		 * @tc.name webgl_test_blendColor_1
		 * @tc.desc Test blendColor.
		 */
		it('webgl_test_blendColor_1', 0, async function(done) {
			
			console.info("webgltest into blendColor");

			gl.blendColor(1, 1, 1, 1);
			const blendColorValue = gl.getParameter(gl.BLEND_COLOR);
			console.info("blendColor --> getParameter: " + blendColorValue);

			var blendColorArr = new Float32Array([1, 1, 1, 1]);

			// 判断数据类型是否正确
			expect(blendColorValue.constructor).assertEqual(blendColorArr.constructor);
			// 判断数据值是否正确
			expect(blendColorValue.toString()).assertEqual(blendColorArr.toString());

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_1600
		 * @tc.name webgl_test_blendEquation
		 * @tc.desc Test blendEquation.
		 */
		it('webgl_test_blendEquation', 0, async function(done) {
			
			console.info("webgltest into blendEquation");

			gl.blendEquation(gl.FUNC_ADD);

			const blendEquationValue = gl.getParameter(gl.BLEND_EQUATION_RGB);
			console.info("blendEquation --> getParameter: " + blendEquationValue);
			expect(blendEquationValue).assertEqual(gl.FUNC_ADD);

			
			done();
		});

		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_1700
		 * @tc.name webgl_test_blendEquation_1
		 * @tc.desc Test blendEquation.
		 */
		it('webgl_test_blendEquation_1', 0, async function(done) {
			
			console.info("webgltest into blendEquation");

			gl.blendEquation(gl.FUNC_ADD);

			const blendEquationValue2 = gl.getParameter(gl.BLEND_EQUATION_ALPHA);
			console.info("blendEquation --> getParameter: " + blendEquationValue2);
			expect(blendEquationValue2).assertEqual(32774);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_1800
		 * @tc.name webgl_test_blendEquationSeparate
		 * @tc.desc Test blendEquationSeparate.
		 */
		it('webgl_test_blendEquationSeparate', 0, async function(done) {
			
			console.info("webgltest into blendEquationSeparate");
			gl.blendEquationSeparate(gl.FUNC_ADD, gl.FUNC_SUBTRACT);

			const blendEquationSeparateValue = gl.getParameter(gl.BLEND_EQUATION_RGB);
			console.info("blendEquation --> getParameter: " + blendEquationSeparateValue);
			expect(blendEquationSeparateValue).assertEqual(gl.FUNC_ADD);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_1900
		 * @tc.name webgl_test_blendFunc
		 * @tc.desc Test blendFunc.
		 */
		it('webgl_test_blendFunc', 0, async function(done) {
			
			console.info("webgltest into blendFunc");

			gl.enable(gl.BLEND);

			gl.blendFunc(gl.SRC_COLOR, gl.DST_COLOR);

			const blendFuncValue = gl.getParameter(gl.BLEND_SRC_RGB);
			console.info("blendFunc --> getParameter: " + blendFuncValue);
			expect(blendFuncValue).assertEqual(gl.SRC_COLOR);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_2000
		 * @tc.name webgl_test_blendFuncSeparate
		 * @tc.desc Test blendFuncSeparate.
		 */
		it('webgl_test_blendFuncSeparate', 0, async function(done) {
			
			console.info("webgltest into blendFuncSeparate");

			gl.enable(gl.BLEND);

			gl.blendFuncSeparate(gl.SRC_COLOR, gl.DST_COLOR, gl.ONE, gl.ZERO);

			const blendFuncSeparateParameter = gl.getParameter(gl.BLEND_SRC_RGB)
			console.info("blendFuncSeparate --> getParameter: " + blendFuncSeparateParameter);
			expect(blendFuncSeparateParameter).assertEqual(gl.SRC_COLOR);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_2100
		 * @tc.name webgl_test_checkFramebufferStatus2
		 * @tc.desc Test checkFramebufferStatus.
		 */
		it('webgl_test_checkFramebufferStatus2', 0, async function(done) {
			
			console.info("webgltest into checkFramebufferStatus");

			var framebuffer = gl.createFramebuffer();
			gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);

			const checkFramebufferStatus = gl.checkFramebufferStatus(gl.FRAMEBUFFER);
			console.info("createFramebuffer --> bindFramebuffer --> checkFramebufferStatus: " +
				checkFramebufferStatus);
			expect(checkFramebufferStatus).assertEqual(gl.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_2200
		 * @tc.name webgl_test_checkFramebufferStatus_1
		 * @tc.desc Test checkFramebufferStatus.
		 */
		it('webgl_test_checkFramebufferStatus_1', 0, async function(done) {
			
			console.info("webgltest into checkFramebufferStatus");

			var framebuffer = gl.createFramebuffer();
			gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);

			gl.deleteFramebuffer(framebuffer);

			const checkFrameBufferStatus2 = gl.checkFramebufferStatus(gl.FRAMEBUFFER);
			console.info(
				"createFramebuffer --> bindFramebuffer --> deleteFramebuffer --> checkFrameBufferStatus2: " +
				checkFrameBufferStatus2);
			expect(checkFrameBufferStatus2).assertEqual(gl.FRAMEBUFFER_COMPLETE);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_2300
		 * @tc.name webgl_test_clear
		 * @tc.desc Test clear.
		 */
		it('webgl_test_clear', 0, async function(done) {
			
			console.info("webgltest into clear");
			gl.clear(gl.COLOR_BUFFER_BIT);
			var float32Array = new Float32Array([0, 0, 0, 0]);
			const clearParameter = gl.getParameter(gl.COLOR_CLEAR_VALUE);
			console.info("webgltest clear getParameter: " + clearParameter);
			expect(typeof(clearParameter)).assertEqual(typeof(float32Array));
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_2400
		 * @tc.name webgl_test_clearColor
		 * @tc.desc Test clearColor.
		 */
		it('webgl_test_clearColor', 0, async function(done) {
			
			console.info("webgltest into clearColor");
			gl.clearColor(1, 0.5, 0.5, 3);

			const clearColorParameter = gl.getParameter(gl.COLOR_CLEAR_VALUE);

			var float32ArrayValue = new Float32Array([1, 0.5, 0.5, 3]);

			console.info("webgltest clearColor: " + clearColorParameter);
			expect(clearColorParameter.toString()).assertEqual(float32ArrayValue.toString());
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_2500
		 * @tc.name webgl_test_clearDepth
		 * @tc.desc Test clearDepth.
		 */
		it('webgl_test_clearDepth', 0, async function(done) {
			
			console.info("webgltest into clearDepth");

			//用于设置深度缓冲区的深度清除值。
			gl.clearDepth(0.5);
			//若要获取当前深度清除值，查询DEPTH_CLEAR_VALUE 常量。
			const clearDepthValue = gl.getParameter(gl.DEPTH_CLEAR_VALUE);
			// 0.5
			console.info("webgltest clearDepth --> getParameter: " + clearDepthValue);

			expect(clearDepthValue).assertEqual(0.5);
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_2600
		 * @tc.name webgl_test_clearDepth_2
		 * @tc.desc Test clearDepth.
		 */
		it('webgl_test_clearDepth_2', 0, async function(done) {
			
			console.info("webgltest into clearDepth");

			//用于设置深度缓冲区的深度清除值。
			gl.clearDepth(1);
			//若要获取当前深度清除值，查询DEPTH_CLEAR_VALUE 常量。
			const clearDepthValue = gl.getParameter(gl.DEPTH_CLEAR_VALUE);
			// 0.5
			console.info("webgltest clearDepth --> getParameter: " + clearDepthValue);

			expect(clearDepthValue).assertEqual(1);
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_2700
		 * @tc.name webgl_test_clearStencil
		 * @tc.desc Test clearStencil.
		 */
		it('webgl_test_clearStencil', 0, async function(done) {
			
			console.info("webgltest into clearStencil");

			gl.clearStencil(1);
			//要获取当前模板清除值，请查询STENCIL_CLEAR_VALUE 常量。
			const clearStencilValue = gl.getParameter(gl.STENCIL_CLEAR_VALUE);
			console.info("webgltest clearStencil --> getParameter: " + clearStencilValue);
			expect(clearStencilValue).assertEqual(1);

			
			done();
		});

		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_2800
		 * @tc.name webgl_test_clearStencil_1
		 * @tc.desc Test clearStencil.
		 */
		it('webgl_test_clearStencil_1', 0, async function(done) {
			
			console.info("webgltest into clearStencil");

			gl.clearStencil(20);
			//要获取当前模板清除值，请查询STENCIL_CLEAR_VALUE 常量。
			const clearStencilValue = gl.getParameter(gl.STENCIL_CLEAR_VALUE);
			console.info("webgltest clearStencil --> getParameter: " + clearStencilValue);
			expect(clearStencilValue).assertEqual(20);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_2900
		 * @tc.name webgl_test_colorMask
		 * @tc.desc Test colorMask.
		 */
		it('webgl_test_colorMask', 0, async function(done) {
			
			console.info("webgltest into colorMask");

			gl.colorMask(true, true, true, false);
			// 要获取当前的颜色掩码，请查询COLOR_WRITEMASK返回Array.
			const colorMaskValue = gl.getParameter(gl.COLOR_WRITEMASK);
			// [true, true, true, false]
			console.info("webgltest colorMask --> getParameter: " + colorMaskValue);

			expect(colorMaskValue.toString()).assertEqual('true,true,true,false');
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_3000
		 * @tc.name webgl_test_colorMask_1
		 * @tc.desc Test colorMask.
		 */
		it('webgl_test_colorMask_1', 0, async function(done) {
			
			console.info("webgltest into colorMask");

			gl.colorMask(false, false, false, false);
			// 要获取当前的颜色掩码，请查询COLOR_WRITEMASK返回Array.
			const colorMaskValue = gl.getParameter(gl.COLOR_WRITEMASK);
			// [true, true, true, false]
			console.info("webgltest colorMask --> getParameter: " + colorMaskValue);

			expect(colorMaskValue.toString()).assertEqual('false,false,false,false');
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_3100
		 * @tc.name webgl_test_compileShader
		 * @tc.desc Test compileShader.
		 */
		it('webgl_test_compileShader', 0, async function(done) {
			
			console.info("webgltest into compileShader");

			var shader = gl.createShader(gl.VERTEX_SHADER);
			gl.shaderSource(shader, VSHADER_SOURCE);
			gl.compileShader(shader);

			let errorCode = gl.getError();
			console.info("webgltest compileShader getError: " + errorCode);
			expect(errorCode).assertEqual(gl.NO_ERROR);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_3200
		 * @tc.name webgl_test_copyTexImage2D_01
		 * @tc.desc Test copyTexImage2D_01.
		 */
		it('webgl_test_copyTexImage2D_01', 0, async function(done) {
			
			console.info("webgltest into copyTexImage2D_01");
			gl.copyTexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 0, 0, 512, 512, 0);
			let errorCode = gl.getError();
			console.info("webgltest copyTexImage2D_01 getError: " + errorCode);
			expect(errorCode).assertEqual(gl.NO_ERROR);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_3300
		 * @tc.name webgl_test_copyTexImage2D_02
		 * @tc.desc Test copyTexImage2D_02.
		 */
		it('webgl_test_copyTexImage2D_02', 0, async function(done) {
			
			console.info("webgltest into copyTexImage2D_02");
			gl.copyTexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 0, 0, '512', 512, 0);
			let errorCode = gl.getError();
			console.info("webgltest copyTexImage2D_02 getError: " + errorCode);
			expect(errorCode).assertEqual(gl.NO_ERROR);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_3400
		 * @tc.name webgl_test_copyTexSubImage2D
		 * @tc.desc Test copyTexSubImage2D.
		 */
		it('webgl_test_copyTexSubImage2D', 0, async function(done) {
			
			console.info("webgltest into copyTexSubImage2D");

			gl.copyTexSubImage2D(gl.TEXTURE_2D, 0, 0, 0, 0, 0, 16, 16);
			let errorCode = gl.getError();
			console.info("webgltest copyTexSubImage2D getError: " + errorCode);
			expect(errorCode).assertEqual(gl.NO_ERROR);

			
			done();
		});

		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_3500
		 * @tc.name webgl_test_copyTexSubImage2D_1
		 * @tc.desc Test copyTexSubImage2D.
		 */
		it('webgl_test_copyTexSubImage2D_1', 0, async function(done) {
			
			console.info("webgltest into copyTexSubImage2D");

			gl.copyTexSubImage2D(gl.TEXTURE_2D, 0, 0, 0, 0, 0, false, 16);
			let errorCode = gl.getError();
			console.info("webgltest copyTexSubImage2D getError: " + errorCode);
			expect(errorCode).assertEqual(gl.NO_ERROR);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_3600
		 * @tc.name webgl_test_createBuffer
		 * @tc.desc Test createBuffer.
		 */
		it('webgl_test_createBuffer', 0, async function(done) {
			
			console.info("webgltest into createBuffer");

			const buffer = gl.createBuffer();

			gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
			const isBufferValue = gl.isBuffer(buffer);
			console.info("isBufferValue: " + isBufferValue);

			console.info("webgltest createBuffer bindBuffer isBuffer: " + isBufferValue);
			expect(isBufferValue).assertEqual(true);

			
			done();
		});

		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_3700
		 * @tc.name webgl_test_createBuffer_1
		 * @tc.desc Test createBuffer.
		 */
		it('webgl_test_createBuffer_1', 0, async function(done) {
			
			console.info("webgltest into createBuffer");

			const buffer = gl.createBuffer();

			const isBufferValue = gl.isBuffer(buffer);
			console.info("isBufferValue: " + isBufferValue);

			console.info("webgltest createBuffer bindBuffer isBuffer: " + isBufferValue);
			expect(isBufferValue).assertEqual(false);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_3800
		 * @tc.name webgl_test_createFramebuffer
		 * @tc.desc Test createFramebuffer.
		 */
		it('webgl_test_createFramebuffer', 0, async function(done) {
			
			console.info("webgltest into createFramebuffer");

			const framebuffer = gl.createFramebuffer();

			gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
			const isFramebuffer = gl.isFramebuffer(framebuffer);
			console.info("webgltest createFramebuffer --> bindFramebuffer --> isFramebuffer: " +
				isFramebuffer);
			expect(isFramebuffer).assertEqual(true);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_3900
		 * @tc.name webgl_test_createFramebuffer_1
		 * @tc.desc Test createFramebuffer.
		 */
		it('webgl_test_createFramebuffer_1', 0, async function(done) {
			
			console.info("webgltest into createFramebuffer");

			const framebuffer = gl.createFramebuffer();

			const isFramebuffer = gl.isFramebuffer(framebuffer);
			console.info("webgltest createFramebuffer --> bindFramebuffer --> isFramebuffer: " +
				isFramebuffer);
			expect(isFramebuffer).assertEqual(false);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_4000
		 * @tc.name webgl_test_createProgram
		 * @tc.desc Test createProgram.
		 */
		it('webgl_test_createProgram', 0, async function(done) {
			
			console.info("webgltest into createProgram");
			const program = gl.createProgram();
			const isProgram = gl.isProgram(program);
			console.info("webgltest createProgram isProgram: " + isProgram);
			expect(isProgram).assertEqual(true);
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_4100
		 * @tc.name webgl_test_createRenderbuffer
		 * @tc.desc Test createRenderbuffer.
		 */
		it('webgl_test_createRenderbuffer', 0, async function(done) {
			
			console.info("webgltest into createRenderbuffer");

			const renderbuffer = gl.createRenderbuffer();
			gl.bindRenderbuffer(gl.RENDERBUFFER, renderbuffer);
			const isRenderBuffer = gl.isRenderbuffer(renderbuffer);
			console.info(
				"createRenderbuffer --> bindRenderbuffer --> getParameter --> isRenderbuffer: " +
				isRenderBuffer);
			expect(isRenderBuffer).assertEqual(true);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_4200
		 * @tc.name webgl_test_createRenderbuffer_1
		 * @tc.desc Test createRenderbuffer.
		 */
		it('webgl_test_createRenderbuffer_1', 0, async function(done) {
			
			console.info("webgltest into createRenderbuffer");

			const renderbuffer = gl.createRenderbuffer();
			const isRenderBuffer = gl.isRenderbuffer(renderbuffer);
			console.info(
				"createRenderbuffer --> bindRenderbuffer --> getParameter --> isRenderbuffer: " +
				isRenderBuffer);
			expect(isRenderBuffer).assertEqual(false);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_4300
		 * @tc.name webgl_test_createShader
		 * @tc.desc Test createShader.
		 */
		it('webgl_test_createShader', 0, async function(done) {
			
			console.info("webgltest into createShader");

			const shader = gl.createShader(gl.VERTEX_SHADER);
			const isShader = gl.isShader(shader);
			console.info("webgltest createShader isShader: " + isShader);
			expect(isShader).assertEqual(true);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_4400
		 * @tc.name webgl_test_createTexture
		 * @tc.desc Test createTexture.
		 */
		it('webgl_test_createTexture', 0, async function(done) {
			
			console.info("webgltest into createTexture");

			const texture = gl.createTexture();
			gl.bindTexture(gl.TEXTURE_2D, texture);
			const isTexture = gl.isTexture(texture);
			console.info("webgltest createTexture isTexture: " + isTexture);
			expect(isTexture).assertEqual(true);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_4500
		 * @tc.name webgl_test_createTexture_1
		 * @tc.desc Test createTexture.
		 */
		it('webgl_test_createTexture_1', 0, async function(done) {
			
			console.info("webgltest into createTexture");

			const texture = gl.createTexture();
			const isTexture = gl.isTexture(texture);
			console.info("webgltest createTexture isTexture: " + isTexture);
			expect(isTexture).assertEqual(false);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_4600
		 * @tc.name webgl_test_cullFace
		 * @tc.desc Test cullFace.
		 */
		it('webgl_test_cullFace', 0, async function(done) {
			
			console.info("webgltest into cullFace");

			gl.enable(gl.CULL_FACE);
			gl.cullFace(gl.FRONT_AND_BACK);
			// 需要 CULL_FACE_MODE 常量来检查当前多边形剔除模式。
			const cullFaceparameter = gl.getParameter(gl.CULL_FACE_MODE)
			console.info("cullFace --> getParameter: " + cullFaceparameter);
			expect(cullFaceparameter).assertEqual(gl.FRONT_AND_BACK);

			
			done();
		});

		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_4700
		 * @tc.name webgl_test_cullFace_2
		 * @tc.desc Test cullFace.
		 */
		it('webgl_test_cullFace_2', 0, async function(done) {
			
			console.info("webgltest into cullFace");

			gl.enable(gl.CULL_FACE);
			gl.cullFace(gl.FRONT);
			// 需要 CULL_FACE_MODE 常量来检查当前多边形剔除模式。
			const cullFaceparameter = gl.getParameter(gl.CULL_FACE_MODE)
			console.info("cullFace --> getParameter: " + cullFaceparameter);
			expect(cullFaceparameter).assertEqual(gl.FRONT);

			
			done();
		});

		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_4800
		 * @tc.name webgl_test_cullFace_3
		 * @tc.desc Test cullFace.
		 */
		it('webgl_test_cullFace_3', 0, async function(done) {
			
			console.info("webgltest into cullFace");

			gl.enable(gl.CULL_FACE);
			gl.cullFace(gl.BACK);
			// 需要 CULL_FACE_MODE 常量来检查当前多边形剔除模式。
			const cullFaceparameter = gl.getParameter(gl.CULL_FACE_MODE)
			console.info("cullFace --> getParameter: " + cullFaceparameter);
			expect(cullFaceparameter).assertEqual(gl.BACK);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_4900
		 * @tc.name webgl_test_deleteBuffer
		 * @tc.desc Test deleteBuffer.
		 */
		it('webgl_test_deleteBuffer', 0, async function(done) {
			
			console.info("webgltest into deleteBuffer");

			var buffer = gl.createBuffer();
			gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
			const isBuffer1 = gl.isBuffer(buffer);
			console.info("webgltest createBuffer bindBuffer isBuffer1: " + isBuffer1);
			expect(isBuffer1).assertEqual(true);

			gl.deleteBuffer(buffer);
			const isBuffer2 = gl.isBuffer(buffer);
			console.info("webgltest createBuffer bindBuffer deleteBuffer isBuffer2: " + isBuffer2);
			expect(isBuffer2).assertEqual(false);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_5000
		 * @tc.name webgl_test_deleteBuffer_2
		 * @tc.desc Test deleteBuffer.
		 */
		it('webgl_test_deleteBuffer_2', 0, async function(done) {
			
			console.info("webgltest into deleteBuffer");

			var buffer = gl.createBuffer();

			const isBuffer1 = gl.isBuffer(buffer);
			console.info("webgltest createBuffer bindBuffer isBuffer1: " + isBuffer1);
			expect(isBuffer1).assertEqual(false);

			gl.deleteBuffer(buffer);
			const isBuffer2 = gl.isBuffer(buffer);
			console.info("webgltest createBuffer bindBuffer deleteBuffer isBuffer2: " + isBuffer2);
			expect(isBuffer2).assertEqual(false);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_5100
		 * @tc.name webgl_test_deleteFramebuffer
		 * @tc.desc Test deleteFramebuffer.
		 */
		it('webgl_test_deleteFramebuffer', 0, async function(done) {
			
			console.info("webgltest into deleteFramebuffer");

			var framebuffer = gl.createFramebuffer();
			gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);

			const isFramebuffer1 = gl.isFramebuffer(framebuffer);
			console.info("webgltest createFramebuffer bindFramebuffer isFramebuffer1: " +
				isFramebuffer1);
			expect(isFramebuffer1).assertEqual(true);

			gl.deleteFramebuffer(framebuffer);

			const isFramebuffer2 = gl.isFramebuffer(framebuffer);
			console.info("webgltest createFramebuffer bindFramebuffer isFramebuffer2: " +
				isFramebuffer2);
			expect(isFramebuffer2).assertEqual(false);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_5200
		 * @tc.name webgl_test_deleteProgram
		 * @tc.desc Test deleteProgram.
		 */
		it('webgl_test_deleteProgram', 0, async function(done) {
			
			console.info("webgltest into deleteProgram");

			const program = gl.createProgram();
			const isProgram1 = gl.isProgram(program);
			console.info("webgltest createProgram isProgram1: " + isProgram1);
			expect(isProgram1).assertEqual(true);

			gl.deleteProgram(program);
			const isProgram2 = gl.isProgram(program);
			console.info("webgltest getExtension: " + isProgram2);
			expect(isProgram2).assertEqual(false);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_5300
		 * @tc.name webgl_test_deleteProgram_2
		 * @tc.desc Test deleteProgram.
		 */
		it('webgl_test_deleteProgram_2', 0, async function(done) {
			
			console.info("webgltest into deleteProgram");

			const program = gl.createProgram();

			gl.deleteProgram(program);
			const isProgram2 = gl.isProgram(program);
			console.info("webgltest getExtension: " + isProgram2);
			expect(isProgram2).assertEqual(false);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_5400
		 * @tc.name webgl_test_deleteRenderbuffer
		 * @tc.desc Test deleteRenderbuffer.
		 */
		it('webgl_test_deleteRenderbuffer', 0, async function(done) {
			
			console.info("webgltest into deleteRenderbuffer");

			const renderbuffer = gl.createRenderbuffer();
			gl.bindRenderbuffer(gl.RENDERBUFFER, renderbuffer);
			const isRenderbuffer1 = gl.isRenderbuffer(renderbuffer);
			console.info("webgltest createRenderbuffer bindRenderbuffer isRenderbuffer1: " +
				isRenderbuffer1);
			expect(isRenderbuffer1).assertEqual(true);

			gl.deleteRenderbuffer(renderbuffer);

			const isRenderbuffer2 = gl.isRenderbuffer(renderbuffer);
			console.info(
				"webgltest createRenderbuffer bindRenderbuffer  deleteRenderbuffer isRenderbuffer2: " +
				isRenderbuffer2);
			expect(isRenderbuffer2).assertEqual(false);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_5500
		 * @tc.name webgl_test_deleteShader
		 * @tc.desc Test deleteShader.
		 */
		it('webgl_test_deleteShader', 0, async function(done) {
			
			console.info("webgltest into deleteShader");

			var shader = gl.createShader(gl.VERTEX_SHADER);
			const isShader1 = gl.isShader(shader);
			console.info("webgltest createShader isShader: " + isShader1);
			expect(isShader1).assertEqual(true);

			gl.deleteShader(shader);

			const isShader2 = gl.isShader(shader);
			console.info("webgltest createShader deleteShader isShader2: " + isShader2);
			expect(isShader2).assertEqual(false);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_5600
		 * @tc.name webgl_test_deleteShader_2
		 * @tc.desc Test deleteShader.
		 */
		it('webgl_test_deleteShader_2', 0, async function(done) {
			
			console.info("webgltest into deleteShader");

			var shader = gl.createShader(gl.VERTEX_SHADER);

			gl.deleteShader(shader);

			const isShader2 = gl.isShader(shader);
			console.info("webgltest createShader deleteShader isShader2: " + isShader2);
			expect(isShader2).assertEqual(false);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_5700
		 * @tc.name webgl_test_deleteTexture
		 * @tc.desc Test deleteTexture.
		 */
		it('webgl_test_deleteTexture', 0, async function(done) {
			
			console.info("webgltest into deleteTexture");

			var texture = gl.createTexture();
			gl.bindTexture(gl.TEXTURE_2D, texture);
			const isTexture1 = gl.isTexture(texture);
			console.info("webgltest createTexture isTexture: " + isTexture1);
			expect(isTexture1).assertEqual(true);

			gl.deleteTexture(texture);

			const isTexture2 = gl.isTexture(texture);
			console.info("webgltest createTexture deleteTexture isTexture2: " + isTexture2);
			expect(isTexture2).assertEqual(false);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_5800
		 * @tc.name webgl_test_deleteTexture_2
		 * @tc.desc Test deleteTexture.
		 */
		it('webgl_test_deleteTexture_2', 0, async function(done) {
			
			console.info("webgltest into deleteTexture");

			var texture = gl.createTexture();

			const isTexture1 = gl.isTexture(texture);
			console.info("webgltest createTexture isTexture: " + isTexture1);
			expect(isTexture1).assertEqual(false);

			gl.deleteTexture(texture);

			const isTexture2 = gl.isTexture(texture);
			console.info("webgltest createTexture deleteTexture isTexture2: " + isTexture2);
			expect(isTexture2).assertEqual(false);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_5900
		 * @tc.name webgl_test_depthFunc
		 * @tc.desc Test depthFunc.
		 */
		it('webgl_test_depthFunc', 0, async function(done) {
			
			console.info("webgltest into depthFunc");

			gl.enable(gl.DEPTH_TEST);
			gl.depthFunc(gl.NEVER);
			// 要检查当前深度函数，请查询DEPTH_FUNC常量。
			const depthParameter = gl.getParameter(gl.DEPTH_FUNC);
			console.info("depthFunc --> getParameter: " + depthParameter);
			expect(depthParameter).assertEqual(gl.NEVER);

			
			done();
		});

		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_6000
		 * @tc.name webgl_test_depthFunc_2
		 * @tc.desc Test depthFunc.
		 */
		it('webgl_test_depthFunc_2', 0, async function(done) {
			
			console.info("webgltest into depthFunc");

			gl.enable(gl.DEPTH_TEST);
			gl.depthFunc(gl.LESS);
			// 要检查当前深度函数，请查询DEPTH_FUNC常量。
			const depthParameter = gl.getParameter(gl.DEPTH_FUNC);
			console.info("depthFunc --> getParameter: " + depthParameter);
			expect(depthParameter).assertEqual(gl.LESS);

			
			done();
		});

		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_6100
		 * @tc.name webgl_test_depthFunc_3
		 * @tc.desc Test depthFunc.
		 */
		it('webgl_test_depthFunc_3', 0, async function(done) {
			
			console.info("webgltest into depthFunc");

			gl.enable(gl.DEPTH_TEST);
			gl.depthFunc(gl.EQUAL);
			// 要检查当前深度函数，请查询DEPTH_FUNC常量。
			const depthParameter = gl.getParameter(gl.DEPTH_FUNC);
			console.info("depthFunc --> getParameter: " + depthParameter);
			expect(depthParameter).assertEqual(gl.EQUAL);

			
			done();
		});

		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_6200
		 * @tc.name webgl_test_depthFunc_4
		 * @tc.desc Test depthFunc.
		 */
		it('webgl_test_depthFunc_4', 0, async function(done) {
			
			console.info("webgltest into depthFunc");

			gl.enable(gl.DEPTH_TEST);
			gl.depthFunc(gl.LEQUAL);
			// 要检查当前深度函数，请查询DEPTH_FUNC常量。
			const depthParameter = gl.getParameter(gl.DEPTH_FUNC);
			console.info("depthFunc --> getParameter: " + depthParameter);
			expect(depthParameter).assertEqual(gl.LEQUAL);

			
			done();
		});

		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_6300
		 * @tc.name webgl_test_depthFunc_5
		 * @tc.desc Test depthFunc.
		 */
		it('webgl_test_depthFunc_5', 0, async function(done) {
			
			console.info("webgltest into depthFunc");

			gl.enable(gl.DEPTH_TEST);
			gl.depthFunc(gl.GREATER);
			// 要检查当前深度函数，请查询DEPTH_FUNC常量。
			const depthParameter = gl.getParameter(gl.DEPTH_FUNC);
			console.info("depthFunc --> getParameter: " + depthParameter);
			expect(depthParameter).assertEqual(gl.GREATER);

			
			done();
		});

		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_6400
		 * @tc.name webgl_test_depthFunc_6
		 * @tc.desc Test depthFunc.
		 */
		it('webgl_test_depthFunc_6', 0, async function(done) {
			
			console.info("webgltest into depthFunc");

			gl.enable(gl.DEPTH_TEST);
			gl.depthFunc(gl.NOTEQUAL);
			// 要检查当前深度函数，请查询DEPTH_FUNC常量。
			const depthParameter = gl.getParameter(gl.DEPTH_FUNC);
			console.info("depthFunc --> getParameter: " + depthParameter);
			expect(depthParameter).assertEqual(gl.NOTEQUAL);

			
			done();
		});

		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_6500
		 * @tc.name webgl_test_depthFunc_7
		 * @tc.desc Test depthFunc.
		 */
		it('webgl_test_depthFunc_7', 0, async function(done) {
			
			console.info("webgltest into depthFunc");

			gl.enable(gl.DEPTH_TEST);
			gl.depthFunc(gl.GEQUAL);
			// 要检查当前深度函数，请查询DEPTH_FUNC常量。
			const depthParameter = gl.getParameter(gl.DEPTH_FUNC);
			console.info("depthFunc --> getParameter: " + depthParameter);
			expect(depthParameter).assertEqual(gl.GEQUAL);

			
			done();
		});

		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_6600
		 * @tc.name webgl_test_depthFunc_8
		 * @tc.desc Test depthFunc.
		 */
		it('webgl_test_depthFunc_8', 0, async function(done) {
			
			console.info("webgltest into depthFunc");

			gl.enable(gl.DEPTH_TEST);
			gl.depthFunc(gl.ALWAYS);
			// 要检查当前深度函数，请查询DEPTH_FUNC常量。
			const depthParameter = gl.getParameter(gl.DEPTH_FUNC);
			console.info("depthFunc --> getParameter: " + depthParameter);
			expect(depthParameter).assertEqual(gl.ALWAYS);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_6700
		 * @tc.name webgl_test_depthMask
		 * @tc.desc Test depthMask.
		 */
		it('webgl_test_depthMask', 0, async function(done) {
			
			console.info("webgltest into depthMask");

			gl.depthMask(false);
			// 要获得当前的深度遮罩值，传入 DEPTH_WRITEMASK 常量，返回  Boolean.
			const depthMaskValue = gl.getParameter(gl.DEPTH_WRITEMASK);
			// false
			console.info("webgltest depthMaskValue: " + depthMaskValue);
			expect(depthMaskValue).assertEqual(false);
			
			done();
		});

		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_6800
		 * @tc.name webgl_test_depthMask_2
		 * @tc.desc Test depthMask.
		 */
		it('webgl_test_depthMask_2', 0, async function(done) {
			
			console.info("webgltest into depthMask");

			gl.depthMask(true);
			// 要获得当前的深度遮罩值，传入 DEPTH_WRITEMASK 常量，返回  Boolean.
			const depthMaskValue = gl.getParameter(gl.DEPTH_WRITEMASK);
			// false
			console.info("webgltest depthMaskValue: " + depthMaskValue);
			expect(depthMaskValue).assertEqual(true);
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_6900
		 * @tc.name webgl_test_depthRange
		 * @tc.desc Test depthRange.
		 */
		it('webgl_test_depthRange', 0, async function(done) {
			
			console.info("webgltest into depthRange");

			gl.depthRange(0.2, 0.6);
			// 要检查当前深度范围，请查询DEPTH_RANGE返回一个的常量Float32Array
			const depthRangeValue = gl.getParameter(gl.DEPTH_RANGE);
			// Float32Array[0.2, 0.6]
			const float32ArrayValue = new Float32Array([0.2, 0.6]);
			console.info("webgltest depthRange: " + depthRangeValue);
			expect(depthRangeValue.toString()).assertEqual(float32ArrayValue.toString());
			
			done();
		});

		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_7000
		 * @tc.name webgl_test_depthRange_2
		 * @tc.desc Test depthRange.
		 */
		it('webgl_test_depthRange_2', 0, async function(done) {
			
			console.info("webgltest into depthRange");

			gl.depthRange(0.8, 1.0);
			// 要检查当前深度范围，请查询DEPTH_RANGE返回一个的常量Float32Array
			const depthRangeValue = gl.getParameter(gl.DEPTH_RANGE);
			// Float32Array[0.2, 0.6]
			const float32ArrayValue = new Float32Array([0.8, 1.0]);
			console.info("webgltest depthRange: " + depthRangeValue);
			expect(depthRangeValue.toString()).assertEqual(float32ArrayValue.toString());
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_7100
		 * @tc.name webgl_test_detachShader
		 * @tc.desc Test detachShader.
		 */
		it('webgl_test_detachShader', 0, async function(done) {
			
			console.info("webgltest into detachShader");

			//顶点着色器
			var vertexShader = gl.createShader(gl.VERTEX_SHADER);
			gl.shaderSource(vertexShader, VSHADER_SOURCE);
			gl.compileShader(vertexShader);
			//片元着色器
			var fragmentShader = gl.createShader(gl.FRAGMENT_SHADER); //创建 WebGLShader。
			gl.shaderSource(fragmentShader, FSHADER_SOURCE); //fragmentSrc设置一个 WebGLShader 的源码。
			gl.compileShader(fragmentShader);

			//WebGLProgram
			var program = gl.createProgram(); //创建 WebGLProgram
			gl.attachShader(program, vertexShader); //往 WebGLProgram 添加一个片段或者顶点着色器。
			gl.attachShader(program, fragmentShader);
			gl.linkProgram(program); //链接给入的 WebGLProgram 对象
			gl.detachShader(program, vertexShader); //从一个WebGLProgram中分离一个先前附加的片段或者顶点着色器;
			gl.detachShader(program, fragmentShader);
			gl.deleteShader(vertexShader);
			gl.deleteShader(fragmentShader);

			let errorCode = gl.getError();
			console.info("webgltest uniform3uiv getError: " + errorCode);
			expect(errorCode).assertEqual(gl.NO_ERROR);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_7200
		 * @tc.name webgl_test_disable
		 * @tc.desc Test disable.
		 */
		it('webgl_test_disable', 0, async function(done) {
			
			console.info("webgltest into disable");

			gl.disable(gl.DITHER);
			// 要检查功能是否被禁用，请使用以下WebGLRenderingContext.isEnabled()方法：
			const isEnabled = gl.isEnabled(gl.DITHER);
			// false
			console.info("webgltest disable isEnabled: " + isEnabled);
			expect(isEnabled).assertEqual(false);
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_7300
		 * @tc.name webgl_test_disable_2
		 * @tc.desc Test disable.
		 */
		it('webgl_test_disable_2', 0, async function(done) {
			
			console.info("webgltest into disable");
			gl.enable(gl.DITHER);
			const isEnabled2 = gl.isEnabled(gl.DITHER);
			// true
			console.info("webgltest disable isEnabled2: " + isEnabled2);
			expect(isEnabled2).assertEqual(true);

			gl.disable(gl.DITHER);
			// 要检查功能是否被禁用，请使用以下WebGLRenderingContext.isEnabled()方法：
			const isEnabled = gl.isEnabled(gl.DITHER);
			// false
			console.info("webgltest disable isEnabled: " + isEnabled);
			expect(isEnabled).assertEqual(false);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_7400
		 * @tc.name webgl_test_disableVertexAttribArray
		 * @tc.desc Test disableVertexAttribArray.
		 */
		it('webgl_test_disableVertexAttribArray', 0, async function(done) {
			
			console.info("webgltest into disableVertexAttribArray");
			gl.disableVertexAttribArray(0);
			let errorCode = gl.getError();
			console.info("webgltest disableVertexAttribArray getError: " + errorCode);
			expect(errorCode).assertEqual(gl.NO_ERROR);
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_7500
		 * @tc.name webgl_test_drawArrays
		 * @tc.desc Test drawArrays.
		 */
		it('webgl_test_drawArrays', 0, async function(done) {
			
			console.info("webgltest into drawArrays");

			gl.drawArrays(gl.POINTS, 0, 8);
			let errorCode = gl.getError();
			console.info("webgltest drawArrays getError: " + errorCode);
			expect(errorCode).assertEqual(gl.NO_ERROR);
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_7600
		 * @tc.name webgl_test_drawArrays_2
		 * @tc.desc Test drawArrays.
		 */
		it('webgl_test_drawArrays_2', 0, async function(done) {
			
			console.info("webgltest into drawArrays");

			gl.drawArrays(gl.POINTS, 0, -8);
			let errorCode = gl.getError();
			console.info("webgltest drawArrays getError: " + errorCode);
			expect(errorCode).assertEqual(1281);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_7700
		 * @tc.name webgl_test_drawElements
		 * @tc.desc Test drawElements.
		 */
		it('webgl_test_drawElements', 0, async function(done) {
			
			console.info("webgltest into drawElements");


			// 初始化着色器
			if (!initShaders(gl, VSHADER_SOURCE, FSHADER_SOURCE)) {
				console.log('Failed to intialize shaders.');
				return;
			}

			// 设置顶点位置
			var n = initVertexBuffers(gl);
			if (n < 0) {
				console.log('Failed to set the positions of the vertices');
				return;
			}

			const indexBuffer = gl.createBuffer();
			gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexBuffer);
			gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, indices.buffer, gl.STATIC_DRAW);

			var maxViewPortDimsParameter = gl.getParameter(gl.MAX_VIEWPORT_DIMS);
			console.log('maxViewPortDimsParameter: ' + maxViewPortDimsParameter);
			var viewPortParameter = gl.getParameter(gl.VIEWPORT);
			console.log('viewPortParameter: ' + viewPortParameter);
			var boolParameter = gl.getParameter(gl.BOOL);
			console.log('boolParameter: ' + boolParameter);
			var SamplerCubeParameter = gl.getParameter(gl.SAMPLER_CUBE);
			console.log('SamplerCubeParameter: ' + SamplerCubeParameter);

			const isContextLostValue = gl.isContextLost();
			console.info("isContextLostValue: " + isContextLostValue);

			// 指定清空<canvas>的颜色
			gl.clearColor(0.0, 0.0, 0.0, 1.0);

			// 清空<canvas>
			// COLOR_BUFFER_BIT	0x00004000
			gl.clear(gl.COLOR_BUFFER_BIT);

			console.info("indices.length: " + indices.length)
			gl.drawElements(gl.TRIANGLES, indices.length, gl.UNSIGNED_SHORT, 0);

			let errorCode = gl.getError();
			console.info("webgltest drawArrays getError: " + errorCode);
			expect(errorCode).assertEqual(1280);
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_7800
		 * @tc.name webgl_test_drawElements_2
		 * @tc.desc Test drawElements.
		 */
		it('webgl_test_drawElements_2', 0, async function(done) {
			
			console.info("webgltest into drawElements");

			gl.drawElements(1, 2, 3, 4);

			let errorCode = gl.getError();
			console.info("webgltest drawElements getError: " + errorCode);
			expect(errorCode).assertEqual(0x0500);
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_7900
		 * @tc.name webgl_test_enable
		 * @tc.desc Test enable.
		 */
		it('webgl_test_enable', 0, async function(done) {
			
			console.info("webgltest into enable");

			gl.enable(gl.DITHER);

			const isEnabled = gl.isEnabled(gl.DITHER);
			// true
			console.info("webgltest enable isEnabled: " + isEnabled);
			expect(isEnabled).assertEqual(true);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_8000
		 * @tc.name webgl_test_enable_2
		 * @tc.desc Test enable.
		 */
		it('webgl_test_enable_2', 0, async function(done) {
			
			console.info("webgltest into enable");

			gl.enable(gl.DITHER);

			const isEnabled = gl.isEnabled(gl.DITHER);
			// true
			console.info("webgltest enable isEnabled: " + isEnabled);
			expect(isEnabled).assertEqual(true);

			gl.disable(gl.DITHER);
			// 要检查功能是否被禁用，请使用以下WebGLRenderingContext.isEnabled()方法：
			const isEnabled2 = gl.isEnabled(gl.DITHER);
			// false
			console.info("webgltest disable isEnabled2: " + isEnabled2);
			expect(isEnabled2).assertEqual(false);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_8100
		 * @tc.name webgl_test_enableVertexAttribArray
		 * @tc.desc Test enableVertexAttribArray.
		 */
		it('webgl_test_enableVertexAttribArray', 0, async function(done) {
			
			console.info("webgltest into enableVertexAttribArray");
			//顶点着色器程序
			var VSHADER_SOURCE =
				'attribute vec4 a_Position;\n' +
				'void main() {\n' +
				'  gl_Position = a_Position;\n' +
				'}\n';

			// 片元着色器程序
			var FSHADER_SOURCE =
				'precision mediump float;\n' +
				'uniform vec4 u_FragColor;\n' +
				'void main() {\n' +
				'  gl_FragColor = u_FragColor;\n' +
				'}\n';
			var vertexShader = gl.createShader(gl.VERTEX_SHADER);
			gl.shaderSource(vertexShader, VSHADER_SOURCE);
			gl.compileShader(vertexShader);
			var fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
			gl.shaderSource(fragmentShader, FSHADER_SOURCE);
			gl.compileShader(fragmentShader);
			const programObj = gl.createProgram();
			console.log("testUseProgram has failed for " + programObj)
			const useProgramError1 = gl.getError();
			console.info("useProgramError: " + useProgramError1);
			const renderBufferValue1 = gl.getParameter(gl.CURRENT_PROGRAM);
			console.log("testUseProgram has failed for " + renderBufferValue1)
			gl.attachShader(programObj, vertexShader);
			gl.attachShader(programObj, fragmentShader);
			gl.linkProgram(programObj);
			gl.useProgram(programObj);

			const aVertexPosition = gl.getAttribLocation(programObj, "a_Position");

			gl.enableVertexAttribArray(aVertexPosition);
			gl.vertexAttribPointer(aVertexPosition, 4, gl.FLOAT, false, 0, 0);
			gl.drawArrays(gl.TRIANGLES, 0, 3);

			let errorCode = gl.getError();
			console.info("webgltest enableVertexAttribArray getError: " + errorCode);
			expect(errorCode).assertEqual(gl.NO_ERROR);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_8200
		 * @tc.name webgl_test_finish
		 * @tc.desc Test finish.
		 */
		it('webgl_test_finish', 0, async function(done) {
			
			console.info("webgltest into finish");
			gl.finish();
			let errorCode = gl.getError();
			console.info("webgltest finish getError: " + errorCode);
			expect(errorCode).assertEqual(gl.NO_ERROR);
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_8300
		 * @tc.name webgl_test_flush
		 * @tc.desc Test flush.
		 */
		it('webgl_test_flush', 0, async function(done) {
			
			console.info("webgltest into flush");
			gl.flush();
			let errorCode = gl.getError();
			console.info("webgltest flush getError: " + errorCode);
			expect(errorCode).assertEqual(gl.NO_ERROR);
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_8400
		 * @tc.name webgl_test_framebufferRenderbuffer
		 * @tc.desc Test framebufferRenderbuffer.
		 */
		it('webgl_test_framebufferRenderbuffer', 0, async function(done) {
			
			console.info("webgltest into framebufferRenderbuffer");

			const renderbuffer = gl.createRenderbuffer();
			gl.framebufferRenderbuffer(gl.DRAW_FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER,
				renderbuffer);

			let errorCode = gl.getError();
			console.info("webgltest framebufferRenderbuffer getError: " + errorCode);
			expect(errorCode).assertEqual(gl.NO_ERROR);
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_8500
		 * @tc.name webgl_test_framebufferRenderbuffer_2
		 * @tc.desc Test framebufferRenderbuffer.
		 */
		it('webgl_test_framebufferRenderbuffer_2', 0, async function(done) {
			
			console.info("webgltest into framebufferRenderbuffer");

			const renderbuffer = gl.createRenderbuffer();
			gl.framebufferRenderbuffer(gl.DRAW_FRAMEBUFFER, "11", gl.RENDERBUFFER, renderbuffer);

			let errorCode = gl.getError();
			console.info("webgltest framebufferRenderbuffer getError: " + errorCode);
			expect(errorCode).assertEqual(gl.NO_ERROR);
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_8600
		 * @tc.name webgl_test_framebufferTexture2D
		 * @tc.desc Test framebufferTexture2D.
		 */
		it('webgl_test_framebufferTexture2D', 0, async function(done) {
			
			console.info("webgltest into framebufferTexture2D");
			const texture = gl.createTexture();
			gl.framebufferTexture2D(gl.DRAW_FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture,
				0);

			let errorCode = gl.getError();
			console.info("webgltest framebufferTexture2D getError: " + errorCode);
			expect(errorCode).assertEqual(gl.NO_ERROR);

			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_8700
		 * @tc.name webgl_test_framebufferTexture2D_1
		 * @tc.desc Test framebufferTexture2D.
		 */
		it('webgl_test_framebufferTexture2D_1', 0, async function(done) {
			
			console.info("webgltest into framebufferTexture2D");
			const texture = gl.createTexture();
			gl.framebufferTexture2D(gl.DRAW_FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture,
				"123");

			let errorCode = gl.getError();
			console.info("webgltest framebufferTexture2D getError: " + errorCode);
			expect(errorCode).assertEqual(gl.NO_ERROR);

			
			done();
		});


		//********************************************* webgl2 ******************************************************

		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_8800
		 * @tc.name webgl_test_drawBuffers
		 * @tc.desc Test drawBuffers.
		 */
		it('webgl_test_drawBuffers', 0, async function(done) {
			
			console.info("webgltest into drawBuffers");

			gl2.drawBuffers([gl2.NONE, gl2.COLOR_ATTACHMENT1]);

			let errorCode = gl.getError();
			console.info("webgltest drawBuffers getError: " + errorCode);
			expect(errorCode).assertEqual(gl.NO_ERROR);
			
			done();
		});

		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_8900
		 * @tc.name webgl_test_drawBuffers_2
		 * @tc.desc Test drawBuffers.
		 */
		it('webgl_test_drawBuffers_2', 0, async function(done) {
			
			console.info("webgltest into drawBuffers");
			gl2.drawBuffers(["gl2.NONE", "gl2.COLOR_ATTACHMENT1"]);
			let errorCode = gl.getError();
			console.info("webgltest drawBuffers getError: " + errorCode);
			expect(errorCode).assertEqual(gl.NO_ERROR);
			
			done();
		});

		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_9000
		 * @tc.name webgl_test_clearBufferfv
		 * @tc.desc Test clearBufferfv.
		 */
		it('webgl_test_clearBufferfv', 0, async function(done) {
			
			console.info("webgltest into clearBufferfv");

			gl2.clearBufferfv(gl.COLOR, 0, [0.0, 0.0, 0.0, 0.0]);

			let errorCode = gl.getError();
			console.info("webgltest webgl_test_clearBufferfv getError: " + errorCode);
			expect(errorCode).assertEqual(gl.NO_ERROR);
			
			done();
		});

		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_9100
		 * @tc.name webgl_test_clearBufferfv_2
		 * @tc.desc Test clearBufferfv.
		 */
		it('webgl_test_clearBufferfv_2', 0, async function(done) {
			
			console.info("webgltest into clearBufferfv");

			gl2.clearBufferfv(gl.COLOR, "0", [0.0, 0.0, 0.0, 0.0]);

			let errorCode = gl.getError();
			console.info("webgltest webgl_test_clearBufferfv getError: " + errorCode);
			expect(errorCode).assertEqual(gl.NO_ERROR);
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_9200
		 * @tc.name webgl_test_clearBufferiv
		 * @tc.desc Test clearBufferiv.
		 */
		it('webgl_test_clearBufferiv', 0, async function(done) {
			
			console.info("webgltest into clearBufferiv");

			gl2.clearBufferiv(gl.COLOR, 0, new Int32Array([0, 1, 0, 0.5]));

			let errorCode = gl.getError();
			console.info("webgltest clearBufferiv getError: " + errorCode);
			expect(errorCode).assertEqual(gl.NO_ERROR);
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_9300
		 * @tc.name webgl_test_clearBufferiv_2
		 * @tc.desc Test clearBufferiv.
		 */
		it('webgl_test_clearBufferiv_2', 0, async function(done) {
			
			console.info("webgltest into clearBufferiv");

			gl2.clearBufferiv(gl.COLOR, "0", new Int32Array([0, 1, 0, 0.5]));

			let errorCode = gl.getError();
			console.info("webgltest clearBufferiv getError: " + errorCode);
			expect(errorCode).assertEqual(gl.NO_ERROR);
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_9400
		 * @tc.name webgl_test_clearBufferuiv
		 * @tc.desc Test clearBufferuiv.
		 */
		it('webgl_test_clearBufferuiv', 0, async function(done) {
			
			console.info("webgltest into clearBufferuiv");

			gl2.clearBufferuiv(gl.COLOR, 0, new Uint32Array([0, 1, 0, 0]));

			let errorCode = gl.getError();
			console.info("webgltest clearBufferuiv getError: " + errorCode);
			expect(errorCode).assertEqual(gl.NO_ERROR);
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_9500
		 * @tc.name webgl_test_clearBufferuiv_2
		 * @tc.desc Test clearBufferuiv.
		 */
		it('webgl_test_clearBufferuiv_2', 0, async function(done) {
			
			console.info("webgltest into clearBufferuiv");

			gl2.clearBufferuiv(gl.COLOR, "0", new Uint32Array([0, 1, 0, 0]));

			let errorCode = gl.getError();
			console.info("webgltest clearBufferuiv getError: " + errorCode);
			expect(errorCode).assertEqual(gl.NO_ERROR);
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_9600
		 * @tc.name webgl_test_clearBufferfi
		 * @tc.desc Test clearBufferfi.
		 */
		it('webgl_test_clearBufferfi', 0, async function(done) {
			
			console.info("webgltest into clearBufferfi");

			gl2.clearBufferfi(gl.DEPTH_STENCIL, 0, 1.0, 0);

			let errorCode = gl.getError();
			console.info("webgltest clearBufferfi getError: " + errorCode);
			expect(errorCode).assertEqual(gl.NO_ERROR);
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_9700
		 * @tc.name webgl_test_clearBufferfi_2
		 * @tc.desc Test clearBufferfi.
		 */
		it('webgl_test_clearBufferfi_2', 0, async function(done) {
			
			console.info("webgltest into clearBufferfi");

			gl2.clearBufferfi(gl.DEPTH_STENCIL, "0", 1.0, 0);

			let errorCode = gl.getError();
			console.info("webgltest clearBufferfi getError: " + errorCode);
			expect(errorCode).assertEqual(gl.NO_ERROR);
			
			done();
		});


		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_9800
		 * @tc.name webgl_test_createQuery
		 * @tc.desc Test createQuery.
		 */
		it('webgl_test_createQuery', 0, async function(done) {
			
			console.info("webgltest into createQuery");

			const query = gl2.createQuery();
			gl2.beginQuery(0x8C2F, query);

			const currentQuery = gl2.getQuery(gl2.ANY_SAMPLES_PASSED, 0x8865);
			const isQuery = gl2.isQuery(currentQuery);

			console.info("webgltest createQuery isQuery: " + isQuery);
			expect(isQuery).assertEqual(true);
			
			done();
		});

		/**
		 * @tc.number SUB_BASIC_GRAPHICS_SPECIAL_XTS_WEBGL_01_9900
		 * @tc.name webgl_test_beginQuery
		 * @tc.desc Test beginQuery.
		 */
		it('webgl_test_beginQuery', 0, async function(done) {
			
			console.info("webgltest into beginQuery");

			var query = gl2.createQuery();
			gl2.beginQuery(0x8C2F, query);

			const currentQuery = gl2.getQuery(0x8C2F, 0x8865);
			const isQuery1 = gl2.isQuery(currentQuery);
			console.info("webgltest createQuery isQuery1: " + isQuery1);
			expect(isQuery1).assertEqual(true);
			
			done();
		});
	})
	}
